home *** CD-ROM | disk | FTP | other *** search
/ Revista do CD-ROM 88 / CD-ROM 88.iso / internet / imsweb / isetup.exe / _SETUP.1 / vmhtm23.js < prev    next >
Encoding:
Text File  |  2002-07-05  |  43.8 KB  |  1,817 lines
  1. //*********************************************************************************//
  2. // (C) Copyright Virtual Mechanics 1999-2002 Version 2.4a, All rights reserved.     //
  3. // All copies of any portions of this software must include this Copyright notice. //
  4. //*********************************************************************************//
  5. objStep = new Array();
  6. objTime = new Array();
  7. noStep = new Array();
  8. TotTime = new Array();
  9. maxTime = new Array();
  10. noStep = new Array();
  11. Mctl = new Array();
  12. workX = new Array();
  13. workY = new Array();
  14.  
  15. var Version = 0;
  16. var newPage = 0;
  17. var pgScObj =-1;
  18. var pageObj = 0;
  19. var mW;
  20. var mH;
  21. nm = new Array();
  22. Active = new Array();
  23. ob   = new Array();
  24. cpox = new Array();
  25. cpoy = new Array();
  26. spox = new Array();
  27. spoy = new Array();
  28. epox = new Array();
  29. epoy = new Array();
  30. crot = new Array();
  31. cscx = new Array();
  32. cscy = new Array();
  33. rotate= new Array();
  34. scale= new Array();
  35. rate = new Array();
  36. var Lpox;
  37. var Lpoy;
  38. dpox = new Array();
  39. dpoy = new Array();
  40. atDis  = new Array();
  41. DisPt  = new Array();
  42. disStep = new Array();
  43. Plen = new Array();
  44. Path = new Array();
  45. obRef= new Array();
  46. Gtyp = new Array();
  47. Gnpt=new Array();
  48. //Gnam = new Array();
  49. Glen = new Array();
  50. Gszx = new Array();
  51. Gszy = new Array();
  52. Gorx = new Array();
  53. Gory = new Array();
  54. Gpxl = new Array();
  55. Gpyl = new Array();
  56. Gbrl = new Array();
  57. Gbrt = new Array();
  58. Gbrr = new Array();
  59. Gbrb = new Array();
  60. Grps = new Array();
  61. Grpl = new Array();
  62. Gspt = new Array();
  63. Snam = new Array();
  64. Scnt = new Array();
  65. PathCount = new Array();
  66. LastPt  = new Array();
  67. lstVal = new Array();
  68.  
  69. TimeLeft = new Array();
  70. AEvent = new Array();
  71. WDEvent = new Array();
  72. WAEvent = new Array();
  73. AValue = new Array();
  74. ATime = new Array();
  75. AEnter = new Array();
  76. ALeave = new Array();
  77. AKey = new Array();
  78. IKey = new Array();
  79. DEvent = new Array();
  80. DValue = new Array();
  81. DTime = new Array();
  82. DEnter = new Array();
  83. DLeave = new Array();
  84. DAKey = new Array();
  85. DIKey = new Array();
  86. WASOp  = new Array();
  87. WAGOp  = new Array();
  88. OpForm = new Array();
  89. WAAObj = new Array();
  90. WADObj = new Array();
  91. WAForm = new Array();
  92. WASVal = new Array();
  93. WAGVal = new Array();
  94. WACgeo = new Array();
  95. WACsnd = new Array();
  96. WACact = new Array();
  97. WACevt = new Array();
  98. WACatt = new Array();
  99. WACobj = new Array();
  100. WANobj = new Array();
  101. WALink = new Array();
  102. WDAObj = new Array();
  103. WDDObj = new Array();
  104. EndPath = new Array();
  105. MType = new Array();
  106.  
  107. MPath  = new Array();
  108. MRate  = new Array();
  109. MTime  = new Array();
  110. MDelay = new Array();
  111. MStart = new Array();
  112. MRepeat= new Array();
  113. MCount = new Array();
  114. MPLen  = new Array();
  115. MDir   = new Array();
  116. MGWst  = new Array();
  117. MGNth  = new Array();
  118. MGEst  = new Array();
  119. MGSth  = new Array();
  120. MALst  = new Array();
  121. MRotate= new Array();
  122. MScale = new Array();
  123. MShade = new Array();
  124. MFlags = new Array();
  125.  
  126. eDELAY = (1);
  127. eDELAY_TIME = (2);
  128. eMOUSE = (4);
  129. eMOUSE_OVER = (8);
  130. eLMOUSE = (16);
  131. eRMOUSE = (32);
  132. eKEY = (64);
  133. eOBJECT_ENTER = (128);
  134. eOBJECT_ENTER_LIST = (256);
  135. eOBJECT_LEAVE = (512);
  136. eOBJECT_LEAVE_LIST = (1024);
  137. eLT_VALUE =    (2048);
  138. eEQ_VALUE = (4096);
  139. eGT_VALUE =    (8192);
  140. eVALUE      = (16384);
  141. eENDPATH  = (32768);
  142. eACTIVATE_1 = (65536);
  143. eACTIVATE_2    = (131072);
  144. eANDtest = (1<<30);
  145. var pageTime = -1;// link timer
  146. var Cobj;
  147. var Csty;
  148. var Catt;
  149. var Cact;
  150. var Cevt;
  151. var Cgrp;
  152. var Cgeo;
  153. var Csnd;
  154. var Cpob;
  155. var Gpgo;
  156. var gcx;
  157. var gcy;
  158. var gcx;
  159. var gcy;
  160. var cmx = 0;
  161. var cmy = 0;
  162. var smx = -9999;
  163. var smy = -9999;
  164. var slm = 0;
  165. var llm = -9999;
  166. var sky = " ";
  167. var lstsnd = -1;
  168. var fact;
  169. var ifact;
  170.  
  171. var lmx = -9999;
  172. var lmy = -9999;
  173. var lky = 0;
  174. var totObj;
  175. var mS;
  176. var mW;
  177. var fps = 30;
  178. var waitTime = 20;
  179. var tickTime = 1;
  180. var strDate;
  181. var curDate;
  182. var GEO_TYPE = 7;
  183. var GEO_OPEN = 8;
  184. var GEO_COUNT= 32;
  185. ACT_XPATH_STOP     =(0);
  186. ACT_XPATH_OBJPTH =(1<<0);
  187. ACT_XPATH_OBJXYZ =(1<<1);
  188. ACT_XPATH_LEFT   =(1<<2);
  189. ACT_XPATH_RIGHT  =(1<<3);
  190. ACT_XPATH_MOUSE     =(1<<4);
  191. ACT_XPATH_KEYPTH =(1<<5);
  192. ACT_YPATH_STOP     =(0);
  193. ACT_YPATH_OBJPTH =(1<<8);
  194. ACT_YPATH_OBJXYZ =(1<<9);
  195. ACT_YPATH_UP     =(1<<10);
  196. ACT_YPATH_DOWN   =(1<<11);
  197. ACT_YPATH_MOUSE     =(1<<12);
  198. ACT_ZPATH_STOP     =(0);
  199. ACT_ZPATH_OBJPTH =(1<<16);
  200. ACT_ZPATH_OBJXYZ =(1<<17);
  201. ACT_ZPATH_IN     =(1<<18);
  202. ACT_ZPATH_OUT     =(1<<19);
  203. ACT_ZPATH_KEY     =(1<<20);
  204. ACT_PATH_STOP     =(0);
  205. ACT_PATH_START     =(1<<24);
  206. ACT_PATH_CENTER     =(1<<25);
  207. ACT_PATH_END     =(1<<26);
  208. ACT_GEO_WEST     =(1<<28);
  209. ACT_GEO_EAST     =(1<<29);
  210. ACT_GEO_NORTH    =(1<<30);
  211. ACT_GEO_SOUTH    =(1<<31);
  212. ACT_SETX         =(0xffffff00);
  213. ACT_SETY         =(0xffff00ff);
  214. ACT_SETZ         =(0xff00ffff);
  215. ACT_SETO         =(0xf0ffffff);
  216. ACT_SETF         =(0x0fffffff);
  217. ACT_GETX         =(0x000000ff);
  218. ACT_GETY         =(0x0000ff00);
  219. ACT_GETZ         =(0x00ff0000);
  220. ACT_GETO         =(0x0f000000);
  221. ACT_GETF         =(0xf0000000);
  222.  
  223. /**************************************************************************/
  224. var isNav4 = false, isIE4 = false, isIE5 = false, isNC6 = false;
  225. if (document.getElementById)
  226. {
  227.  isIE5 = true;// NN6, IE5, Opera 5
  228.  if(!document.all)
  229.  {
  230.     isNC6 = true; //nc6 && ie5 possible
  231.  }
  232. }
  233. else if (document.all)
  234. {
  235.  isIE4 = true;// IE4
  236. }
  237. else if (document.layers)
  238. {
  239.  isNav4 = true;// NN4
  240. }
  241. ///////////////////////////////////////
  242. if (isIE4 || isIE5)  { 
  243.     if(isNC6)
  244.     {
  245.          window.document.onmousemove = NNmouseMove;
  246.          window.document.onmousedown = NNmouseDown;
  247.         window.document.onmouseup   = NNmouseUp;
  248.           window.document.onkeypress  = NNkeyPress;
  249.  
  250.         window.document.ondragstart = IECancelEvent;
  251.     }
  252.     else
  253.     {
  254.         window.document.onmousemove = IEmouseMove;
  255.          window.document.onmousedown = IEmouseDown;
  256.         window.document.onmouseup   = IEmouseUp;
  257.          window.document.onkeypress  = IEkeyPress;
  258.          window.document.onkeydown   = IEkeyPress;
  259.         window.document.ondragstart = IECancelEvent;
  260.     }
  261.  
  262. }
  263. else if (isNav4) {
  264.     window.captureEvents(Event.MOUSEUP|Event.MOUSEDOWN|Event.MOUSEMOVE|Event.KEYPRESS);
  265.     window.onmousedown=NNmouseDown;
  266.     window.onmouseup=NNmouseUp;
  267.     window.onmousemove=NNmouseMove;
  268.     window.onkeypress=NNkeyPress;
  269. }
  270.  
  271. /////////////////////////////////////
  272. function NNmouseMove(e) {
  273.     cmx = e.pageX;
  274.     cmy = e.pageY;
  275.     sclx = window.pageXOffset;
  276.     scly = window.pageYOffset;
  277. }
  278. function NNmouseDown(e) {
  279.     slm = slm | 1;
  280.     document.onmousemove=drag;
  281.     document.onmouseup=enddrag;
  282.     smx=e.pageX;
  283.     smy=e.pageY;  
  284.     return true;
  285. }
  286.  
  287. function NNmouseUp(e) {
  288.     slm = slm | 2; 
  289.     smx = e.pageX; 
  290.     smy = e.pageY; 
  291. }
  292.  
  293. function NNkeyPress(e) {
  294.     
  295.     if(isNC6){
  296.  
  297.         sky = e.which;
  298.     }
  299.     else{
  300.  
  301.         sky = String.fromCharCode(e.which);
  302.     } 
  303. }
  304. function enddrag(e) {
  305.     slm = slm | 2;
  306.     smx = e.pageX + window.pageXOffset;
  307.     smy = e.pageY + window.pageYOffset;
  308.     document.onmousemove=0;
  309.     document.releaseEvents(Event.MOUSEMOVE);
  310.     document.releaseEvents(Event.MOUSEUP);
  311.     window.captureEvents(Event.MOUSEMOVE|Event.MOUSEDOWN|Event.KEYPRESS);
  312.     return false;
  313. }
  314. function drag(e) {
  315.     cmx = e.pageX + window.pageXOffset;
  316.     cmy = e.pageY + window.pageYOffset;
  317. }
  318.  
  319. /////////////////////////
  320. function IEmouseMove() {
  321.     cmx = window.event.clientX + document.body.scrollLeft;
  322.     cmy = window.event.clientY + document.body.scrollTop;
  323.     sclx = document.body.scrollLeft;
  324.     scly = document.body.scrollTop;
  325. }
  326.  
  327. function IEmouseDown() {
  328.     slm = slm | 1;
  329.     smx = window.event.clientX + document.body.scrollLeft;
  330.     smy = window.event.clientY + document.body.scrollTop;
  331. }
  332.  
  333. function IEmouseUp() {
  334.     slm = slm | 2;
  335.     smx = window.event.clientX + document.body.scrollLeft;
  336.     smy = window.event.clientY + document.body.scrollTop;
  337. }
  338.  
  339. function IEkeyPress() {
  340.     sky = window.event.keyCode;
  341. }
  342. function IECancelEvent() {
  343.     window.event.returnValue=false;
  344. }
  345. ////////////////////////
  346. function Setup() {
  347. // setup defaults
  348.     tmCount=0;
  349.  
  350.     strDate = new Date();
  351.     waitTime = 1000 / fps;
  352.     frmTime = 0;
  353.     tickTime = 0;
  354.     
  355.     obRef[0] = 0;
  356.     ob[0] = new Array();
  357.     ob[0] = 0;
  358.     ob[0].geom = "Geo0";
  359.     ob[0].geo = 0;
  360.     ob[0].att = 0; 
  361.     ob[0].evt = 0; 
  362.     ob[0].act = 0;
  363.     ob[0].grp = 0;
  364.     ob[0].cpox =0.000000;
  365.     ob[0].cpoy =0.000000;
  366.     ob[0].cscx =1.000000;
  367.     ob[0].cscy =1.000000;
  368.     ob[0].crot =0.000000;
  369.     ob[0].flg = 0;
  370.  
  371.     MPath[0]  = 0;
  372.     MStart[0] = 0;
  373.     MCount[0] = 0;
  374.  
  375.     fact = 1.0;
  376.     ifact= 0.0;
  377.  
  378.     for(nob=0; nob < pageObj; nob++) {
  379.         Cobj = pObjLst[nob];
  380.         spox[Cobj] = ob[Cobj].cpox;  
  381.         spoy[Cobj] = ob[Cobj].cpoy;
  382.         SetPath(Cobj);
  383.  
  384.         if(ob[Cobj].grp == 0)
  385.                 reset(Cobj);
  386.  
  387.         if(ob[Cobj].flg & 16)
  388.             Active[Cobj] =  4;    // set to initial active state
  389.     }
  390. }
  391.  
  392. function doObjectList() {
  393.  
  394.     curDate = new Date();
  395.     tickTime = (curDate - strDate) * 0.1;
  396.     frmTime++;
  397.  
  398.     if(newPage != 0) window.location=WALink[newPage];
  399.  
  400.     newPage = 0;
  401.     if(pageTime >= 0)
  402.     {
  403.         tmCount++;
  404.         if(tmCount > pageTime * tickTime) 
  405.         {
  406.             window.location=pgLink;
  407.             pageTime = -1;
  408.         }
  409.     }
  410.  
  411.     if(lmx == smx) smx = -99999;
  412.     if(lmy == smy) smy = -99999;
  413.     if(lky == sky) sky = " ";
  414.     llt = 0;
  415.     if((llm & 2) == (slm & 2)) slm = (slm  & ~2);
  416.     if((llm & 1) == (slm & 1)) slm = (slm  & ~1);
  417.     lmx = smx;
  418.     lmy = smy;
  419.     lky = sky;
  420.     llm = slm;
  421.  
  422.     MoOvrTst();
  423.  
  424.     for(nob=0; nob < pageObj; nob++) {
  425. //        ref = pObjLst[nob];
  426.         gcx = 0;
  427.         gcy = 0;
  428.         cobj = pObjLst[nob]
  429.         Cgrp = ob[cobj].grp;
  430.         if(!Cgrp) doObject(cobj);
  431.     }
  432. }
  433.  
  434. function doObject(cobj)
  435. {
  436.     Cobj = cobj;
  437.     Cgeo = ob[Cobj].geo;
  438.     Csnd = ob[Cobj].snd;
  439.     Cevt = ob[Cobj].evt;
  440.     Catt = ob[Cobj].att;
  441.     Cact = ob[Cobj].act;
  442.     Gpgo = ob[Cobj].gem;
  443.     Csty = ob[Cobj].style;
  444.  
  445.     if(Cact)
  446.     {            
  447.         Cpob = MPath[Cact];
  448.         if(Cpob)
  449.             Cpgo = ob[Cpob].geo;
  450.         else
  451.             Cpgo = 0;
  452.     }
  453.     else
  454.     {
  455.         Cpob = 0;
  456.         Cpgo = 0;
  457.     }
  458.  
  459.     if(Cevt) Evtest();
  460.  
  461.     if     (Active[Cobj] == 4) whenActive();
  462.     else if(Active[Cobj] == 2) whenDeactive();
  463.     else if(Active[Cobj] == 1) isActive();
  464.     else if(Active[Cobj] == 0) isDeactive();
  465.  
  466. //    if(Cgeo && (Gtyp[Cgeo] & (1<<4)))
  467. //    { 
  468. //        doGroup(Cgeo);
  469. //        return;
  470. //    }
  471.  
  472. }
  473.  
  474. function doGroup(cgrp)
  475. {
  476.     var gobj;
  477.     gcx = cpox[Cobj];
  478.     gcy = cpoy[Cobj];
  479.     gobj = Cobj;
  480.     for(i = 0; i < Grps[cgrp]; i++)
  481.     { 
  482.         doObject(Grpl[cgrp][i]);
  483.         ob[Cobj].style.left=gcx+cpox[Cobj] - Gszx[Cgeo] * ob[Cobj].cscx;
  484.         ob[Cobj].style.top =gcy+cpoy[Cobj] - Gszy[Cgeo] * ob[Cobj].cscy;
  485.     }
  486.     return;
  487. }
  488.  
  489. function setVisibility(code)
  490. {
  491. if(Gtyp[Cgeo] & (1<<6)) return;
  492.     if(Cgeo && (Gtyp[Cgeo] & (1<<4))) {
  493.         for(i = 0; i < Grps[Cgeo]; i++) {
  494.             ob[Grpl[Cgeo][i]].style.visibility = code;
  495.         }
  496.             ob[Grpl[Cgeo][i]].style.visibility = code;
  497.     }
  498.     else
  499.         ob[Cobj].style.visibility = code;
  500. }
  501.  
  502. function UpdGeo() {
  503.     var drx = Lpox - cpox[Cobj];
  504.     var dry = Lpoy - cpoy[Cobj];
  505.     if(Math.abs(dry) > Math.abs(drx))
  506.     {
  507.         if    ((dry < 0) && (MDir[Cobj] != 270))
  508.         {
  509.             if(MType[Cact] & (ACT_GEO_SOUTH))
  510.             {
  511.                 ob[Cobj].geo.src = Gspt[MGSth[Cact]].src;
  512.             }
  513.             MDir[Cobj] = 270;
  514.         }
  515.         else  if((dry >= 0) && MDir[Cobj] != 90)
  516.         {
  517.             if(MType[Cact] & (ACT_GEO_NORTH))
  518.             { 
  519.                 ob[Cobj].geom.src = Gspt[MGNth[Cact]].src;
  520.             }
  521.             MDir[Cobj] = 90;
  522.         }
  523.     }
  524.     else
  525.     {
  526.         if    ((drx > 0) && (MDir[Cobj] != 0))
  527.         {
  528.             if(MType[Cact] & (ACT_GEO_WEST))
  529.             { 
  530.                 ob[Cobj].geom.src = Gspt[MGWst[Cact]].src;
  531.             }
  532.             MDir[Cobj] = 0;
  533.         }
  534.         else  if((drx <= 0) && MDir[Cobj] != 180)
  535.         {
  536.             if(MType[Cact] & (ACT_GEO_EAST))
  537.             { 
  538. //window.status = " Cobj=" + Cobj + " Cact=" + Cact + " MGEst[Cact]=" + MGEst[Cact] + "Gspt[MGEst[Cact]].src " + Gspt[MGEst[Cact]];
  539. //window.status = " Cobj=" + Cobj + " Cact=" + Cact + " MGEst[Cact]=" + MGEst[Cact] + "Gspt[MGEst[Cact]].src " + Gspt[MGEst[Cact]];
  540. //window.status = " ob[Cobj]=" + ob[Cobj] + " ob[Cobj].geom=" + ob[Cobj].geom.src;
  541.                 ob[Cobj].geom.src = Gspt[MGEst[Cact]].src;
  542.             }
  543.             MDir[Cobj] = 180;
  544.         }
  545.     }
  546. return;
  547. }
  548.  
  549. function UpdStr() {
  550.     if(lstVal[Cobj] == ob[Cobj].val) return;
  551.     lstVal[Cobj] = ob[Cobj].val;
  552.     if(isIE4 || isIE5)
  553.         ob[Cobj].geom.innerText = ob[Cobj].val;
  554.     else
  555.         window.status = "Object " + ob[Cobj].geom + " Counter=" + ob[Cobj].val;
  556.  
  557.     return;
  558. }
  559.  
  560. function UpdAudio(on)
  561. {
  562.     if(isIE4 || isIE5)
  563.     {
  564.         if(on > 0)
  565.         {
  566.             if(Scnt[Csnd] < 0) Scnt[Csnd] = 9999;
  567.             SoundEffect.loop= Scnt[Csnd];
  568.             SoundEffect.src = Snam[Csnd];
  569. //            SoundEffect.autostart=1;
  570.             lstsnd = Csnd;
  571.         }
  572.         else
  573.         {
  574.             if(lstsnd != Csnd) return;
  575.             SoundEffect.src= " ";
  576.             SoundEffect.loop= 0;
  577.             SoundEffect.autostart=0;
  578.         }
  579.     }
  580.     else if(isNav4) 
  581.     {
  582. //        <embed id = BackMusic  src=Snam[Csnd] autostart=true loop= Scnt[Csnd] hidden=true></embed>
  583.     }
  584. }
  585.  
  586.  
  587. /****************************************************************************/
  588. function Evtest() 
  589. {
  590.     if(Active[Cobj] == 0) 
  591.     {
  592.         if(AEvent[Cevt] & eANDtest)
  593.             ActANDTest();
  594.         else
  595.             ActORTest();
  596.     }
  597.     else if(Active[Cobj] == 1) {
  598.         if(DEvent[Cevt] & eANDtest)
  599.             DeactANDTest();
  600.         else
  601.             DeactORTest();
  602.     }
  603. return;
  604. }
  605. /***************************************************************************/
  606. function ActORTest()
  607. {
  608. if(((AEvent[Cevt] & eDELAY)         && TimeCount() <= 0  ) ||
  609.   ( (AEvent[Cevt] & eOBJECT_ENTER)    && ObjectEnter(AEnter[Cevt])  ) ||
  610.   ( (AEvent[Cevt] & eOBJECT_LEAVE)     && ObjectLeave(ALeave[Cevt])  ) ||
  611.   ( (AEvent[Cevt] & eMOUSE)            && MouseSelect() > 0 ) ||
  612.   ( (AEvent[Cevt] & eMOUSE_OVER)    && MouseOver()   ) ||
  613.   ( (AEvent[Cevt] & eLMOUSE)        && IsMouseLClick()   ) ||
  614.   ( (AEvent[Cevt] & eKEY)            && KeyChar()   ) ||
  615.   ( (AEvent[Cevt] & eLT_VALUE)        && ob[Cobj].val <  AValue[Cevt]) ||
  616.   ( (AEvent[Cevt] & eEQ_VALUE)        && ob[Cobj].val == AValue[Cevt]) ||
  617.   ( (AEvent[Cevt] & eGT_VALUE)        && ob[Cobj].val >  AValue[Cevt]) ||
  618.   ( (AEvent[Cevt] & eENDPATH)        && EndPath[Cobj]     )   )
  619. Active[Cobj] = 4;
  620. }
  621. /***************************************************************************/
  622. function ActANDTest()
  623. {
  624. if(((AEvent[Cevt] & eDELAY)         && !(TimeCount() <= 0)  ) ||
  625.   ( (AEvent[Cevt] & eOBJECT_ENTER)    && !ObjectEnter(AEnter[Cevt])  ) ||
  626.   ( (AEvent[Cevt] & eOBJECT_LEAVE)     && !ObjectLeave(ALeave[Cevt])  ) ||
  627.   ( (AEvent[Cevt] & eMOUSE)            && !(MouseSelect() > 0) ) ||
  628.   ( (AEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  629.   ( (AEvent[Cevt] & eLMOUSE)        && !IsMouseLClick()   ) ||
  630.   ( (AEvent[Cevt] & eKEY)            && !KeyChar()   ) ||
  631.   ( (AEvent[Cevt] & eLT_VALUE)        && !(ob[Cobj].val <  AValue[Cevt])) ||
  632.   ( (AEvent[Cevt] & eEQ_VALUE)        && !(ob[Cobj].val == AValue[Cevt])) ||
  633.   ( (AEvent[Cevt] & eGT_VALUE)        && !(ob[Cobj].val >  AValue[Cevt])) ||
  634.   ( (AEvent[Cevt] & eENDPATH)        && !EndPath[Cobj]     )   )
  635.   {} else Active[Cobj] = 4;
  636. }
  637. /***************************************************************************/
  638. function DeactORTest()
  639. {
  640.  
  641. if(((DEvent[Cevt] & eDELAY)         && TimeCount() <= 0  ) ||
  642.   ( (DEvent[Cevt] & eOBJECT_ENTER)    && ObjectEnter(DEnter[Cevt])  ) ||
  643.   ( (DEvent[Cevt] & eOBJECT_LEAVE)     && ObjectLeave(DLeave[Cevt])  ) ||
  644.   ( (DEvent[Cevt] & eMOUSE)            && MouseUp() > 0 ) ||
  645.   ( (DEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  646.   ( (DEvent[Cevt] & eLMOUSE)        && IsMouseLClick()   ) ||
  647.   ( (DEvent[Cevt] & eKEY)            && DKeyChar()   ) ||
  648.   ( (DEvent[Cevt] & eLT_VALUE)        && ob[Cobj].val <  AValue[Cevt]) ||
  649.   ( (DEvent[Cevt] & eEQ_VALUE)        && ob[Cobj].val == AValue[Cevt]) ||
  650.   ( (DEvent[Cevt] & eGT_VALUE)        && ob[Cobj].val >  AValue[Cevt]) ||
  651.   ( (DEvent[Cevt] & eENDPATH)        && EndPath[Cobj]     )   )
  652.     Active[Cobj] = 2;
  653. }
  654. /***************************************************************************/
  655. function DeactANDTest()
  656. {
  657. if(((DEvent[Cevt] & eDELAY)         && !(TimeCount() <= 0)  ) ||
  658.   ( (DEvent[Cevt] & eOBJECT_ENTER)    && !ObjectEnter(DEnter[Cevt])  ) ||
  659.   ( (DEvent[Cevt] & eOBJECT_LEAVE)     && !ObjectLeave(DLeave[Cevt])  ) ||
  660.   ( (DEvent[Cevt] & eMOUSE)            && !(MouseUp() > 0) ) ||
  661.   ( (DEvent[Cevt] & eMOUSE_OVER)    && !MouseOver()   ) ||
  662.   ( (DEvent[Cevt] & eLMOUSE)        && !IsMouseLClick()   ) ||
  663.   ( (DEvent[Cevt] & eKEY)            && !DKeyChar()   ) ||
  664.   ( (DEvent[Cevt] & eLT_VALUE)        && !(ob[Cobj].val <  AValue[Cevt])) ||
  665.   ( (DEvent[Cevt] & eEQ_VALUE)        && !(ob[Cobj].val == AValue[Cevt])) ||
  666.   ( (DEvent[Cevt] & eGT_VALUE)        && !(ob[Cobj].val >  AValue[Cevt])) ||
  667.   ( (DEvent[Cevt] & eENDPATH)        && !EndPath[Cobj]     )   )
  668.   {} else Active[Cobj] = 2;
  669. }
  670. /**************************************************************************/
  671. function TimeCount() {
  672.     return (TimeLeft[Cobj] - tickTime);
  673. }
  674.  
  675. function ObjectEnter(eobj) { 
  676. x = Gszx[Cgeo] * ob[Cobj].cscx;
  677. y = Gszy[Cgeo] * ob[Cobj].cscy;
  678. if ( cpox[eobj] >= (cpox[Cobj] - x) && cpox[eobj] <= (cpox[Cobj]) + x &&
  679.       cpoy[eobj] >= (cpoy[Cobj] - y) && cpoy[eobj] <= (cpoy[Cobj]) + y )
  680.     return 1;
  681. return 0;
  682. }
  683.  
  684. function ObjectLeave(eobj) {
  685. x = Gszx[Cgeo] * ob[Cobj].cscx;
  686. y = Gszy[Cgeo] * ob[Cobj].cscy;
  687. if ( cpox[eobj] >= cpox[Cobj] - x && cpox[eobj] <= cpox[Cobj] + x &&
  688.      cpoy[eobj] >= cpoy[Cobj] - y && cpoy[eobj] <= cpoy[Cobj] + y )
  689.     return 0;
  690. return 1;
  691. }
  692.  
  693. function MouseSelect() {
  694. var val = 0;
  695. if(smx == -99999) return val;
  696. x = Gszx[Cgeo] * ob[Cobj].cscx;
  697. y = Gszy[Cgeo] * ob[Cobj].cscy;
  698. if ( smx >= cpox[Cobj] - x && smx <= cpox[Cobj] + x &&
  699.      smy >= cpoy[Cobj] - y && smy <= cpoy[Cobj] + y )
  700.     return val = 1;
  701. return val;
  702. }
  703.  
  704. function MouseOver() {
  705. x = Gszx[Cgeo] * ob[Cobj].cscx;
  706. y = Gszy[Cgeo] * ob[Cobj].cscy;
  707.  
  708. if ( cmx >= cpox[Cobj] - x && cmx <= cpox[Cobj] + x &&
  709.      cmy >= cpoy[Cobj] - y && cmy <= cpoy[Cobj] + y ) {
  710.           return 1;
  711.     }
  712. return 0;
  713. }
  714.  
  715. function IsMouseLClick() {
  716. return (slm && 1);
  717. }
  718.  
  719. function MouseUp() {
  720. return (slm && 2);
  721. }
  722.  
  723. function KeyChar() {
  724. if(!sky) return 0;
  725. if(isNav4 && (AKey[Cevt] == lky)) return 1;
  726. if((isIE4 || isIE5) && (IKey[Cevt] == lky)) return 1;
  727. return 0;
  728. }
  729.  
  730. function DKeyChar() {
  731. if(!sky) return 0;
  732. if(isNav4 && (DAKey[Cevt] == sky)) return 1;
  733. if((isIE4 || isIE5) && (DIKey[Cevt] == sky)) return 1;
  734. return 0;
  735. }
  736.  
  737. function MoOvrTst() {
  738. for(i=0; i < MoLNo; i++) {
  739.   Cobj = Molst[i];
  740.   Cgeo = ob[Cobj].geo;
  741.   if(Version <= 105) 
  742.   {
  743.       if(MouseOver() == 1) {
  744.         if(ob[Cobj].flg & 256) setVisibility("visible");
  745.         else                   setVisibility("hidden");
  746.       }
  747.       else {
  748.         if(ob[Cobj].flg & 128) setVisibility("visible");
  749.         else                   setVisibility("hidden");
  750.       }
  751.   }
  752.   else if(ob[Cobj].flg & 512) 
  753.   {
  754.       if(MouseOver() == 1) 
  755.       {
  756.         if(ob[Cobj].flg & 128) setVisibility("visible");
  757.         else                   setVisibility("hidden");
  758.       }
  759.       else 
  760.       {
  761.         if(ob[Cobj].flg & 256) setVisibility("visible");
  762.         else                   setVisibility("hidden");
  763.       }
  764.   }
  765. }}
  766.  
  767. /***************************************************************************/
  768. function isDeactive() {
  769.     if(PathCount[Cobj] != 0) UpdPos();
  770.     if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();
  771.  
  772. return;
  773. }
  774.  
  775. function isActive() {
  776.     if(PathCount[Cobj] != 0) UpdPos();
  777.     if(Gtyp[Cgeo] & GEO_COUNT) UpdStr();
  778. return;
  779. }
  780.  
  781. function whenActive()
  782. {
  783.     Active[Cobj]  = 1;
  784.     EndPath[Cobj] = 0;
  785.  
  786.     // set default active events
  787.     if(!Cevt)
  788.     {
  789.         TimeLeft[Cobj]  =  0;
  790.         PathCount[Cobj] = 0;
  791.         setVisibility("visible")
  792.     }
  793.     else
  794.     {
  795. //        if(WAEvent[Cevt] & (1<<14)) window.location=WALink[Cevt];
  796. //        if(WAEvent[Cevt] & (1<<15)) window.location=WALink[Cevt];
  797.         if(WAEvent[Cevt] & (1<<14) || WAEvent[Cevt] & (1<<15)) 
  798.         {
  799.             newPage = Cevt;
  800.         }
  801.  
  802.         if(Csnd > 0) UpdAudio((WAEvent[Cevt] & 16));
  803. //        if(WAEvent[Cevt] & 16) UpdAudio(); //sound
  804.         if(WAEvent[Cevt] & 8) setVisibility("visible");
  805.         else                  setVisibility("hidden");
  806.  
  807.         TimeLeft[Cobj] = tickTime + (DTime[Cevt]);
  808. //        TimeLeft[Cobj] = (DTime[Cevt]);
  809.  
  810.         if(WAEvent[Cevt] & (1<<5)) Active[WAAObj[Cevt]] = 4;
  811.         if(WAEvent[Cevt] & (1<<7)) Active[WADObj[Cevt]] = 2;
  812.  
  813.         // apply value
  814.         if(WAEvent[Cevt] & (1<<13)) {
  815.             if       ((OpForm[Cevt] & 0x000f) == 0)
  816.                 ob[Cobj].val  = WAForm[Cevt];
  817.             else if((OpForm[Cevt] & 0x000f) == 1)
  818.                 ob[Cobj].val += WAForm[Cevt];
  819.             else if((OpForm[Cevt] & 0x000f) == 2)
  820.                 ob[Cobj].val -= WAForm[Cevt];
  821.             else if((OpForm[Cevt] & 0x000f) == 3)
  822.                 ob[Cobj].val *= WAForm[Cevt];
  823.             else if((OpForm[Cevt] & 0x000f) == 4)
  824.                 if(WAForm[Cevt] != 0) ob[Cobj].val /= WAForm[Cevt];
  825.         }
  826.         // get value
  827.         if(WAEvent[Cevt] & (1<<11)) {
  828.             if       ((WAGOp[Cevt] & 0x000f) == 0)
  829.                 ob[Cobj].val  = ob[WAGVal[Cevt]].val;
  830.             else if((WAGOp[Cevt] & 0x000f) == 1)
  831.                 ob[Cobj].val += ob[WAGVal[Cevt]].val;
  832.             else if((WAGOp[Cevt] & 0x000f) == 2)
  833.                 ob[Cobj].val -= ob[WAGVal[Cevt]].val;
  834.             else if((WAGOp[Cevt] & 0x000f) == 3)
  835.                 ob[Cobj].val*= ob[WAGVal[Cevt]].val;
  836.             else if((WAGOp[Cevt] & 0x000f) == 4)
  837.                 if(ob[WAGVal[Cevt]].val != 0) ob[Cobj].val /= ob[WAGVal[Cevt]].val;
  838.         }
  839.         // send result
  840.         if(WAEvent[Cevt] & (1<<9)) {
  841.             if       ((WASOp[Cevt] & 0x000f) == 0)
  842.                 ob[WASVal[Cevt]].val  = ob[Cobj].val;
  843.             else if((WASOp[Cevt] & 0x000f) == 1)
  844.                 ob[WASVal[Cevt]].val += ob[Cobj].val;
  845.             else if((WASOp[Cevt] & 0x000f) == 2)
  846.                 ob[WASVal[Cevt]].val -= ob[Cobj].val;
  847.             else if((WASOp[Cevt] & 0x000f) == 3)
  848.                 ob[WASVal[Cevt]].val *= ob[Cobj].val;
  849.             else if((WASOp[Cevt] & 0x000f) == 4)
  850.                 if(ob[Cobj].val != 0) ob[WASVal[Cobj]].val /= ob[Cobj].val;
  851.         }
  852.          // motion
  853.         if(WAEvent[Cevt] & 4)    PathCount[Cobj] = MCount[Cact];
  854.         else                    PathCount[Cobj] = 0; // motion
  855.         // replace current object components
  856.         if(WAEvent[Cevt] & (1<<17))
  857.         {
  858.             if(WAEvent[Cevt] & (1<<18)) {
  859.                 ob[Cobj].geom = Gspt[WACgeo[Cevt]].src;
  860.                 ob[Cobj].geo  = WACgeo[Cevt];
  861.             }
  862.             if(WAEvent[Cevt] & (1<<18)) ob[Cobj].geo  = WACgeo[Cevt];
  863.             if(WAEvent[Cevt] & (1<<18)) ob[Cobj].geom.src = Gspt[ob[Cobj].geo].src;
  864.             if(WAEvent[Cevt] & (1<<19)) ob[Cobj].att  = WACatt[Cevt];
  865.             if(WAEvent[Cevt] & (1<<20)) ob[Cobj].act  = WACact[Cevt];
  866.             if(WAEvent[Cevt] & (1<<22)) ob[Cobj].evt  = WACevt[Cevt];
  867.             spox[Cobj] = cpox[Cobj];  
  868.             spoy[Cobj] = cpoy[Cobj];
  869.             SetPath(Cobj);
  870.         }
  871.         // replace additional object components
  872.         for(ref=0; ref< WACobj[Cevt]; ref++) {
  873.             if(WAEvent[Cevt] & (1<<18)) {
  874.                 ob[WANobj[Cevt][ref]].geom = Gspt[WACgeo[Cevt]].src;
  875.                 ob[WANobj[Cevt][ref]].geo  = WACgeo[Cevt];
  876.             }
  877.             if(WAEvent[Cevt] & (1<<18)) ob[WANobj[Cevt][ref]].geo  = WACgeo[Cevt];
  878.             if(WAEvent[Cevt] & (1<<18)) ob[WANobj[Cevt][ref]].geom.src = Gspt[ob[Cobj].geo].src;
  879.             if(WAEvent[Cevt] & (1<<19)) ob[WANobj[Cevt][ref]].att  = WACatt[Cevt];
  880.             if(WAEvent[Cevt] & (1<<20)) ob[WANobj[Cevt][ref]].act  = WACact[Cevt];
  881.             if(WAEvent[Cevt] & (1<<22)) ob[WANobj[Cevt][ref]].evt  = WACevt[Cevt];
  882.             spox[WANobj[Cevt][ref]] = cpox[Cobj];  
  883.             spoy[WANobj[Cevt][ref]] = cpoy[Cobj];
  884.             SetPath(WANobj[Cevt][ref]);
  885.         }
  886.  
  887.         if(WAEvent[Cevt] & (1<<30)) reset(Cobj);
  888.     }
  889. }
  890.  
  891. function whenDeactive()
  892. {
  893.  
  894.     EndPath[Cobj] = 0;
  895.     Active[Cobj]  = -1;    // is disabled unless reset
  896.  
  897.     if(!Cevt) 
  898.     {
  899.         PathCount[Cobj] = -1;
  900.         TimeLeft[Cobj]  =  0;
  901.         setVisibility("hidden");
  902.     }
  903.     else
  904.     {
  905.         if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact]; // motion
  906.         if(WDEvent[Cevt] & (1<<30)) reset(Cobj);
  907.  
  908.         if(Csnd > 0) UpdAudio((WDEvent[Cevt] & 16));    //sound
  909.         if(WDEvent[Cevt] & 8) setVisibility("visible");
  910.         else                  setVisibility("hidden");
  911.  
  912.         TimeLeft[Cobj] = tickTime + (ATime[Cevt]);
  913. //        TimeLeft[Cobj] = (ATime[Cevt]);
  914.         if(WDEvent[Cevt] & 4) PathCount[Cobj] = MCount[Cact];    // motion
  915.         else                  PathCount[Cobj] = 0;
  916.  
  917.         if(WDEvent[Cevt] & (1<<5)) Active[WDAObj[Cevt]] = 4;
  918.         if(WDEvent[Cevt] & (1<<7)) Active[WDDObj[Cevt]] = 2;
  919.     }
  920.  
  921. }
  922.  
  923. //**************************************************************************
  924. function reset(cobj) {
  925.  
  926.     Cobj = cobj;
  927.     Csty = ob[cobj].style;
  928.     Cevt = ob[cobj].evt;
  929.     Catt = ob[cobj].att;
  930.     Cact = ob[cobj].act;
  931.     Cgrp = ob[cobj].grp;
  932.     Cgeo = ob[cobj].geo;
  933.     Active[cobj]    =  0;    // is deactive
  934.     if(Cevt)
  935.     {
  936.         if(WDEvent[Cevt] & 8) setVisibility("visible");
  937.         else                  setVisibility("hidden");
  938.         if(WDEvent[Cevt] & (1<<31)) {
  939.             PathCount[cobj] = MCount[Cact];            // restart path
  940.             cpox[cobj] = spox[cobj];
  941.             cpoy[cobj] = spoy[cobj];
  942.             cscx[cobj] = ob[cobj].cscx;
  943.             cscy[cobj] = ob[cobj].cscy;
  944.             crot[cobj] = ob[cobj].crot;
  945.             LastPt[cobj] = 0;
  946. //            atDis[cobj] = 0;
  947.              DisPt[cobj] = 0;
  948.             EndPath[cobj] = 0;
  949.         }
  950.         if(!(WDEvent[Cevt] & 4)) PathCount[cobj] = 0;    // no motion
  951.         TimeLeft[cobj] = tickTime + (ATime[Cevt]);
  952. //        TimeLeft[cobj] = (ATime[Cevt]);
  953.     }
  954.     else if(Cgeo)
  955.     {
  956.         if(ob[cobj].flg & 64)
  957.             setVisibility("visible");
  958.         else
  959.             setVisibility("hidden");
  960.         // set action variables
  961.  
  962.         if(Cact) PathCount[cobj] = MCount[Cact]; // motion
  963.         else     PathCount[cobj] = 0;
  964.         TimeLeft[cobj]  = 0;
  965.  
  966.         cpox[cobj] = spox[cobj];
  967.         cpoy[cobj] = spoy[cobj];
  968.         LastPt[cobj] = 0;
  969. //        atDis[cobj] = 0;
  970.         DisPt[cobj] = 0;
  971.         EndPath[cobj] = 0;
  972.  
  973. //        resetMatrix();
  974. //        appTrans(cobj);
  975. //        if(Cact) appMtrx();
  976.     }
  977.  
  978. return;
  979. }
  980.  
  981. function SetPath(cobj) {
  982.  
  983.     Cobj = cobj;
  984.     Csty = ob[Cobj].sty;    // Style
  985.     Cevt = ob[Cobj].evt;    // Objects event
  986.     Catt = ob[Cobj].att;    // Objects attribute
  987.     Cact = ob[Cobj].act;    // Objects action
  988.     Cgrp = ob[Cobj].grp;    // Objects group
  989.     Cgeo = ob[Cobj].geo;    // Objects geometry
  990.     Csnd = ob[Cobj].snd;    // Objects sound
  991.     Cpob = MPath[Cact];        // Object actions path object
  992.     Cpgo = ob[Cpob].geo;    // Path objects geometry
  993.     lstVal[Cobj] = ob[Cobj].val - 100;
  994.     MDir[Cobj] = -1;
  995.  
  996. // rotation and scaling
  997.     cscx[Cobj] = ob[Cobj].cscx;
  998.     cscy[Cobj] = ob[Cobj].cscy;
  999.     crot[Cobj] = ob[Cobj].crot;
  1000.     rotate[Cobj]= MRotate[Cact];
  1001.     scale[Cobj] = MScale[Cact];
  1002.  
  1003.     cscx[Cobj] = ob[Cobj].cscx;
  1004.     cscy[Cobj] = ob[Cobj].cscy;
  1005.     scale[Cobj]= MScale[Cact];
  1006.  
  1007.     if(!Cact) {
  1008.         Plen[Cobj] = 0;
  1009.         noStep[Cobj] = 0;
  1010.         disStep[Cobj] = 0;
  1011.         dpox[Cobj] = 0;
  1012.         dpoy[Cobj] = 0;
  1013.         PathCount[Cobj] = 0;
  1014.     }
  1015.     else {
  1016. //        if(Version > 206)
  1017. //            rate[Cobj]  = MRate[Cact] * 0.1 / fps;
  1018. //        else
  1019. //            rate[Cobj]  = MRate[Cact];
  1020.         if(Version > 206)
  1021.             rate[Cobj]  = MRate[Cact] * 0.01;
  1022.         else
  1023.             rate[Cobj]  = MRate[Cact];
  1024.         PathCount[Cobj] = MCount[Cact];
  1025.  
  1026.         if(MType[Cact] & ACT_XPATH_MOUSE || MType[Cact] & ACT_YPATH_MOUSE) {
  1027.             Plen[Cobj] = 1;
  1028.             noStep[Cobj] = 1;
  1029.             disStep[Cobj] = 1;
  1030.             dpox[Cobj] = 0;
  1031.             dpoy[Cobj] = 0;
  1032.         }
  1033.         else if(MType[Cact] & ACT_XPATH_OBJPTH || MType[Cact] & ACT_XPATH_OBJXYZ) {
  1034.             objPath(Cobj,Cpob,Cpgo);
  1035.         }
  1036.         else if(MType[Cact] & ACT_XPATH_KEYPTH) {
  1037.             motionSetup(Cobj,Cpob,Cpgo);
  1038.         }
  1039.         else
  1040.         {
  1041.             linPath(Cobj);
  1042.         }
  1043.     }
  1044.     cpox[Cobj] = spox[Cobj];
  1045.     cpoy[Cobj] = spoy[Cobj];
  1046.     LastPt[Cobj] = 0;
  1047.     atDis[Cobj] = 0;
  1048.     DisPt[Cobj] = 0;
  1049.     EndPath[Cobj] = 0;
  1050.  
  1051.     GetStartPos();
  1052. //    atDis[Cobj] = Plen[Cobj] * MStart[Cact];
  1053.     objStep[Cobj] = 0;
  1054.     if(MFlags[Cact] & (1<<20)) 
  1055.     {
  1056.         noStep[Cobj] = MPLen[Cact] * 30;
  1057.     }
  1058.     noStep[Cobj] *= (MPLen[Cact] / 100.);
  1059.  
  1060.     resetMatrix();
  1061.     appTrans(Cobj);
  1062. //    appMtrx();
  1063.     return;
  1064. }
  1065.  
  1066. function getPathLenth(Cobj,Cpob,Cgeo)
  1067. // return lenth of transformed path
  1068. {
  1069.     var i, x = 0.0, y = 0.0;
  1070.     Plen[Cobj] = 0;
  1071.     // find length of rectangle
  1072.     if        ((Gtyp[Cgeo] & GEO_TYPE) == 1) {
  1073.         Plen[Cobj] = 2 * (Gpxl[Cgeo][1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx
  1074.                    + 2 * (Gpyl[Cgeo][1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
  1075.     }
  1076.     // find length of ellipse
  1077.     else if    ((Gtyp[Cgeo] & GEO_TYPE) == 2) {
  1078.         Plen[Cobj] = 360;
  1079.     }
  1080.     // find length of polygon
  1081.     else if    ((Gtyp[Cgeo] & GEO_TYPE) == 3) {
  1082.         for ( i = 1; i < Gnpt[Cgeo]; i++)
  1083.         {
  1084.             x = (Gpxl[Cgeo][i] - Gpxl[Cgeo][i-1]) * ob[Cpob].cscx;
  1085.             y = (Gpyl[Cgeo][i] - Gpyl[Cgeo][i-1]) * ob[Cpob].cscy;
  1086.             Plen[Cobj] += Math.sqrt(x*x + y*y);
  1087.         }
  1088.  
  1089.         if(!(Gtyp[Cgeo] & GEO_OPEN))
  1090.         {
  1091.             x = (Gpxl[Cgeo][Gnpt[Cgeo]-1] - Gpxl[Cgeo][0]) * ob[Cpob].cscx;
  1092.             y = (Gpyl[Cgeo][Gnpt[Cgeo]-1] - Gpyl[Cgeo][0]) * ob[Cpob].cscy;
  1093.             Plen[Cobj] += Math.sqrt(x*x + y*y);
  1094.         }
  1095.     }
  1096. }
  1097.  
  1098. function linPath(Cobj) {
  1099. epox[Cobj] = spox[Cobj];
  1100. epoy[Cobj] = spoy[Cobj];
  1101.  
  1102. var    lh = mH * (MPLen[Cact] / 100.);
  1103. var    lw = mW * (MPLen[Cact] / 100.);
  1104.  
  1105.     if(MType[Cact] & ACT_YPATH_UP) {
  1106.         if(MType[Cact] & ACT_PATH_CENTER) {
  1107.             spoy[Cobj]     += lh;
  1108.             epoy[Cobj] -= lh;
  1109.         }
  1110.         else if(MType[Cact] & ACT_PATH_END) {
  1111.             spoy[Cobj]     += lh;
  1112.         }
  1113.         else if(MType[Cact] & ACT_PATH_START) {
  1114.             epoy[Cobj] -= lh;
  1115.         }
  1116.     }
  1117.     else if(MType[Cact] & ACT_YPATH_DOWN) {
  1118.         if(MType[Cact] & ACT_PATH_START) {
  1119.             epoy[Cobj] += lh;
  1120.         }
  1121.         else if(MType[Cact] & ACT_PATH_END) {
  1122.             spoy[Cobj]     -= lh;
  1123.         }
  1124.         else if(MType[Cact] & ACT_PATH_CENTER) {
  1125.             spoy[Cobj]     -= lh;
  1126.             epoy[Cobj] += lh;
  1127.         }
  1128.     }
  1129.     else if(MType[Cact] & ACT_YPATH_MOUSE) {
  1130.         Plen[Cobj] = 1;
  1131.         noStep[Cobj] = 1;
  1132.         disStep[Cobj] = 1;
  1133.         dpoy[Cobj] = 0;
  1134.         spoy[Cobj] = cpoy[Cobj];
  1135.     }
  1136.  
  1137.     if(MType[Cact] & ACT_XPATH_LEFT) {
  1138.         if(MType[Cact] & ACT_PATH_CENTER) {
  1139.             spox[Cobj]     += lw;
  1140.             epox[Cobj]  -= lw;
  1141.         }
  1142.         else if(MType[Cact] & ACT_PATH_END) {
  1143.             spox[Cobj]     += lw;
  1144.         }
  1145.         else if(MType[Cact] & ACT_PATH_START) {
  1146.             epox[Cobj]  -= lw;
  1147.         }
  1148.     }
  1149.     else if(MType[Cact] & ACT_XPATH_RIGHT) {
  1150.         if(MType[Cact] & ACT_PATH_START) {
  1151.             epox[Cobj]  += lw;
  1152.         }
  1153.         else if(MType[Cact] & ACT_PATH_END) {
  1154.             spox[Cobj]     -= lw;
  1155.         }
  1156.         else if(MType[Cact] & ACT_PATH_CENTER) {
  1157.             spox[Cobj]     -= lw;
  1158.             epox[Cobj]  += lw;
  1159.         }
  1160.     }
  1161.     else if(MType[Cact] & ACT_YPATH_MOUSE) {
  1162.         Plen[Cobj] = 1;
  1163.         noStep[Cobj] = 1;
  1164.         disStep[Cobj] = 1;
  1165.         dpox[Cobj] = 0;
  1166.         spox[Cobj] = cpox[Cobj];
  1167.     }
  1168.     var x = epox[Cobj] - spox[Cobj];
  1169.     var y = epoy[Cobj] - spoy[Cobj];
  1170.     if(x+y)
  1171.     {
  1172.         Plen[Cobj] = Math.sqrt(x*x + y*y);
  1173.         noStep[Cobj]  = Math.abs(Plen[Cobj] / rate[Cobj]);
  1174.         if(noStep[Cobj] < 1) noStep[Cobj] = 1;
  1175.         disStep[Cobj] = Plen[Cobj] / noStep[Cobj];
  1176.         dpox[Cobj] = x / noStep[Cobj];
  1177.         dpoy[Cobj] = y / noStep[Cobj];
  1178.     }
  1179.     else
  1180.     {
  1181.         Plen[Cobj] = 0;
  1182.         dpox[Cobj] = 0;
  1183.         dpoy[Cobj] = 0;
  1184.         disStep[Cobj] = 0;
  1185.     }
  1186.     return
  1187. }
  1188.  
  1189. function objPath(Cobj,Cpob,Cpgo) 
  1190. {
  1191.     if        ((Gtyp[Cpgo] & GEO_TYPE) == 1) {    
  1192.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;  
  1193.         spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1194.         epox[Cobj] = spox[Cobj];
  1195.         epoy[Cobj] = spoy[Cobj];
  1196.     }
  1197.     else if    ((Gtyp[Cpgo] & GEO_TYPE) == 2) {
  1198.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
  1199. //        spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy + Gszy[Cpob] * ob[Cpob].cscy;
  1200.         spoy[Cobj] = (Gpyl[Cpgo][0] + Gszy[Cpgo]) * ob[Cpob].cscy + ob[Cpob].cpoy;
  1201.         epox[Cobj] = spox[Cobj];
  1202.         epoy[Cobj] = spoy[Cobj];
  1203.     }
  1204.     else if    ((Gtyp[Cpgo] & GEO_TYPE) == 3) {
  1205.         spox[Cobj] = Gpxl[Cpgo][0] * ob[Cpob].cscx + ob[Cpob].cpox;
  1206.         spoy[Cobj] = Gpyl[Cpgo][0] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1207.         if(Gtyp[Cpgo] & GEO_OPEN) 
  1208.         {
  1209.             epox[Cobj] = Gpxl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscx + ob[Cpob].cpox;
  1210.             epoy[Cobj] = Gpyl[Cpgo][Gnpt[Cpgo]-1] * ob[Cpob].cscy + ob[Cpob].cpoy;
  1211.         }
  1212.         else 
  1213.         {
  1214.             epox[Cobj] = spox[Cobj];
  1215.             epoy[Cobj] = spoy[Cobj];
  1216.         }
  1217.     }
  1218.  
  1219.     getPathLenth(Cobj,Cpob,Cpgo);
  1220.     if(Cact)
  1221.         noStep[Cobj]  = Math.abs(Plen[Cobj] / rate[Cobj]);
  1222.     else
  1223.         noStep[Cobj] = 0;
  1224.     if(noStep[Cobj] < 1) noStep[Cobj] = 1;
  1225.     disStep[Cobj] = Plen[Cobj] / noStep[Cobj];
  1226.  
  1227.     return;
  1228. }
  1229.  
  1230. function GetStartPos()
  1231. {
  1232. if(Plen[Cobj] == 0 || (MType[Cact] & ACT_XPATH_OBJXYZ)) return;
  1233.  
  1234.     while(atDis[Cobj] < (Plen[Cobj] * MStart[Cact]))
  1235.     {
  1236.         if(MType[Cact] & ACT_XPATH_OBJPTH)
  1237.         {
  1238.             if     ((Gtyp[Cpgo] & GEO_TYPE) == 1)
  1239.                 GetRectLoc();
  1240.             else if((Gtyp[Cpgo] & GEO_TYPE) == 2) 
  1241.             {
  1242.                 GetArcLoc();
  1243.             }
  1244.             else if((Gtyp[Cpgo] & GEO_TYPE) == 3)
  1245.             {
  1246.                 GetPathLoc();
  1247.             }
  1248.             cpox[Cobj] += cpox[Cpob];
  1249.             cpoy[Cobj] += cpoy[Cpob];
  1250.         }
  1251.         else
  1252.         {
  1253.             if(MType[Cact] & ACT_XPATH_MOUSE)
  1254.                 cpox[Cobj] = cmx;
  1255.             else
  1256.                 cpox[Cobj] += dpox[Cobj];
  1257.  
  1258.             if(MType[Cact] & ACT_YPATH_MOUSE)
  1259.                 cpoy[Cobj] = cmy;
  1260.             else
  1261.                 cpoy[Cobj] += dpoy[Cobj];
  1262.         }
  1263.         atDis[Cobj] += disStep[Cobj];
  1264.     }
  1265.  
  1266. }
  1267.  
  1268. function motionSetup(Cobj,Cpob,Cpgo)
  1269. {
  1270. if(!Cobj || !Cpgo || !Cact) return;
  1271.  
  1272. objStep[Cobj] = 0;
  1273. objTime[Cobj] = -MDelay[Cact];
  1274. maxTime[Cobj] = Mctl[Cpgo][Gnpt[Cpgo]-1].tim;
  1275. if(MRepeat[Cact] >= 0)
  1276.  TotTime[Cobj] = MRepeat[Cact] * maxTime[Cobj];
  1277. else 
  1278.  TotTime[Cobj] = -1;
  1279. }
  1280.  
  1281. /////////////////////////////////////////////////
  1282. function UpdPos() {
  1283. if(MType[Cact] & ACT_XPATH_KEYPTH)
  1284.  motionUpdate();
  1285. else
  1286.  animateUpdate();
  1287. }
  1288.  
  1289. function motionUpdate()
  1290. {
  1291.     var res;
  1292.     objTime[Cobj] = tickTime - MDelay[Cact];
  1293.     if(objTime[Cobj] > maxTime[Cobj]) objStep[Cobj] = 0;
  1294.     if((TotTime[Cobj] < 0 || tickTime < TotTime[Cobj]) && objTime[Cobj] > 0 && maxTime[Cobj] > 0)
  1295.         objTime[Cobj] = objTime[Cobj] % (maxTime[Cobj]+1);
  1296.     else if(objTime[Cobj] > maxTime[Cobj])
  1297.         objTime[Cobj] = maxTime[Cobj];
  1298.     else if(objTime[Cobj] < 0)
  1299.         objTime[Cobj] = 0;
  1300.  
  1301.     res = pathUpdate();
  1302.  
  1303.     if(res == 0)
  1304.     {
  1305.         resetMatrix();
  1306.         x = cpox[Cobj] - ob[Cobj].corx;
  1307.         y = cpoy[Cobj] - ob[Cobj].cory;
  1308.         cpox[Cobj] = x * ob[Cpob].m0 + y * ob[Cpob].m2 + ob[Cpob].m4;
  1309.         cpoy[Cobj] = x * ob[Cpob].m1 + y * ob[Cpob].m3 + ob[Cpob].m5;
  1310.         appTrans(Cobj);
  1311.         if(Cact) appMtrx();
  1312.     }
  1313.  
  1314.     return res;
  1315. }
  1316.  
  1317. function pathUpdate()
  1318. {
  1319.  
  1320. if(objTime[Cobj] < Mctl[Cpgo][0].tim) return -1;
  1321. if(objTime[Cobj] > Mctl[Cpgo][Gnpt[Cpgo]-1].tim) return 1;
  1322. while(objTime[Cobj] > Mctl[Cpgo][objStep[Cobj]+1].tim)
  1323. {
  1324.     if((objStep[Cobj] + 1) >= Gnpt[Cpgo]-1)    {
  1325.         objStep[Cobj] = Gnpt[Cpgo]-1;
  1326.         return 1;
  1327.     }
  1328.     else
  1329.         objStep[Cobj]++;
  1330. }
  1331.  
  1332. var cStep = objStep[Cobj];
  1333. var fact = (objTime[Cobj] - Mctl[Cpgo][cStep].tim) / (Mctl[Cpgo][cStep+1].tim-Mctl[Cpgo][cStep].tim);
  1334. if(fact < 0) fact = 0;
  1335. else if(fact > 1) fact = 1.0;
  1336. var ifact = 1.0 - fact;
  1337.  
  1338. cpox[Cobj] = Gpxl[Cpgo][cStep] + ((Gpxl[Cpgo][cStep+1] - Gpxl[Cpgo][cStep]) * fact);
  1339. cpoy[Cobj] = Gpyl[Cpgo][cStep] + ((Gpyl[Cpgo][cStep+1] - Gpyl[Cpgo][cStep]) * fact);
  1340. cscx[Cobj] = Mctl[Cpgo][cStep].sclx + (Mctl[Cpgo][cStep+1].sclx - Mctl[Cpgo][cStep].sclx) * fact;
  1341. cscy[Cobj] = Mctl[Cpgo][cStep].scly + (Mctl[Cpgo][cStep+1].scly - Mctl[Cpgo][cStep].scly) * fact;
  1342. crot[Cobj] = Mctl[Cpgo][cStep].rot + (Mctl[Cpgo][cStep+1].rot - Mctl[Cpgo][cStep].rot) * fact;
  1343.  
  1344. return 0;
  1345. }
  1346.  
  1347. function animateUpdate() {
  1348. Lpox = cpox[Cobj];
  1349. Lpoy = cpoy[Cobj];
  1350. // end of path condition
  1351. if(noStep[Cobj] > 0 && objStep[Cobj] >= noStep[Cobj]) 
  1352. {
  1353.     objStep[Cobj] = 0;
  1354.     atDis[Cobj] = Plen[Cobj] * MStart[Cact];
  1355.     DisPt[Cobj]  = 0;
  1356.     LastPt[Cobj] = 0;
  1357.     cpox[Cobj]   = spox[Cobj];
  1358.     cpoy[Cobj]   = spoy[Cobj];
  1359. //  reverse path, scaling, rotation, shading
  1360.     if(MFlags[Cact] & (1<<11))
  1361.         rate[Cobj] *= -1;
  1362.     if(MFlags[Cact] & (1<<13))
  1363.         rotate[Cobj] *= -1;
  1364.     else
  1365.         crot[cobj] = ob[cobj].crot;
  1366.     if(MFlags[Cact] & (1<<19))
  1367.         scale[Cobj] *= -1;
  1368.     else
  1369.     {
  1370.         cscx[cobj] = ob[cobj].cscx;
  1371.         cscy[cobj] = ob[cobj].cscy;
  1372.     }
  1373. }
  1374.  
  1375. tranUpdate();
  1376.  
  1377. if(Plen[Cobj] != 0) atDis[Cobj] += disStep[Cobj];
  1378. objStep[Cobj]++;
  1379.  
  1380. if(noStep[Cobj] > 0 && objStep[Cobj] >= noStep[Cobj]) 
  1381. {
  1382.     if(PathCount[Cobj] > 0) PathCount[Cobj]--;
  1383.     if(PathCount[Cobj] == 0) {
  1384.         EndPath[Cobj] = 1;
  1385.     }
  1386. }
  1387.  
  1388. if(Cact) UpdGeo();
  1389. if(Cobj == pgScObj) {
  1390. var x = cpox[Cobj]-mW*0.5;
  1391. var y = cpoy[Cobj]-mH*0.5;
  1392. window.scrollTo(x,y);
  1393. }
  1394. return;
  1395. }
  1396.  
  1397. function tranUpdate() 
  1398. {
  1399.     resetMatrix();
  1400.     // calculate rotation
  1401.     if(rotate[Cobj] != 0) 
  1402.     {
  1403.         if(MFlags[Cact] & (1<<12))
  1404.             crot[Cobj] += rotate[Cobj] * 4;
  1405.         else
  1406.             crot[Cobj] = rotate[Cobj] * fact * 360;
  1407.     }
  1408.     // calculate scaling
  1409.     if(scale[Cobj] != 0) 
  1410.     {
  1411.         if(MFlags[Cact] & (1<<18))
  1412.         {
  1413.             cscx[Cobj] += scale[Cobj] / 360.; 
  1414.             cscy[Cobj] += scale[Cobj] / 360.;
  1415.         }
  1416.         else
  1417.         {
  1418.             var flt = (scale[Cobj] > 0) ? fact : ifact;
  1419.             cscx[Cobj] = ob[Cobj].cscx * (flt + 1.);
  1420.             cscy[Cobj] = ob[Cobj].cscy * (flt + 1.);
  1421.         }
  1422.         var fsize = 12 * cscx[Cobj];
  1423.     }
  1424.     // attached to the position of another Object
  1425.     if(MType[Cact] & ACT_XPATH_OBJXYZ) 
  1426.     {    
  1427.         cpox[Cobj] = cpox[Cpob] - ob[Cobj].corx;
  1428.         cpoy[Cobj] = cpoy[Cpob] - ob[Cobj].corx;
  1429.     }
  1430.     // trace an Object path
  1431.     else if(MType[Cact] & ACT_XPATH_OBJPTH)
  1432.     {
  1433.         if     ((Gtyp[Cpgo] & GEO_TYPE) == 1)
  1434.             GetRectLoc();
  1435.         else if((Gtyp[Cpgo] & GEO_TYPE) == 2) 
  1436.         {
  1437.             GetArcLoc();
  1438.         }            
  1439.         else if((Gtyp[Cpgo] & GEO_TYPE) == 3)
  1440.         {
  1441.             GetPathLoc();
  1442.         }
  1443.         x = cpox[Cobj] - ob[Cobj].corx;
  1444.         y = cpoy[Cobj] - ob[Cobj].cory;
  1445.         cpox[Cobj] = x * ob[Cpob].m0 + y * ob[Cpob].m2 + ob[Cpob].m4;
  1446.         cpoy[Cobj] = x * ob[Cpob].m1 + y * ob[Cpob].m3 + ob[Cpob].m5;
  1447.     }
  1448.     // trace the mouse
  1449.     else
  1450.     {
  1451.         if(MType[Cact] & ACT_XPATH_MOUSE)
  1452.             cpox[Cobj] = cmx - ob[Cobj].corx;
  1453.         else
  1454.             cpox[Cobj] += dpox[Cobj]; //^^ is this STOP?
  1455.  
  1456.         if(MType[Cact] & ACT_YPATH_MOUSE)
  1457.             cpoy[Cobj] = cmy - ob[Cobj].cory;
  1458.         else
  1459.             cpoy[Cobj] += dpoy[Cobj];
  1460.     }
  1461.  
  1462.     appTrans(Cobj);
  1463.     if(Cact) appMtrx();
  1464. }
  1465.  
  1466. function GetArcLoc() {
  1467. if(rate[Cobj] > 0) 
  1468. {
  1469.     cpox[Cobj] = (Math.sin(0.017453292*(-atDis[Cobj]-90)) * (Gszx[Cpgo] * 0.5));
  1470.     cpoy[Cobj] = (Math.cos(0.017453292*(-atDis[Cobj]-90)) * (Gszy[Cpgo] * 0.5));
  1471. }
  1472. else 
  1473. {
  1474.     cpox[Cobj] = (Math.sin(0.017453292*(atDis[Cobj]-90)) * (Gszx[Cpgo] * 0.5));
  1475.     cpoy[Cobj] = (Math.cos(0.017453292*(atDis[Cobj]-90)) * (Gszy[Cpgo] * 0.5));
  1476. }
  1477. return;
  1478. }
  1479.  
  1480. function GetPathLoc() {
  1481. var cPt, nPt, x, y, dis=0.0, ratio=0.0, ct = 0;
  1482.  
  1483. if(rate[Cobj] > 0) 
  1484. {
  1485.     while(ct <= Gnpt[Cpgo]) 
  1486.     {
  1487.         ct ++;
  1488.         if(LastPt[Cobj]+1 < Gnpt[Cpgo]) 
  1489.         {
  1490.             cPt = LastPt[Cobj];
  1491.             nPt = cPt + 1; 
  1492.         }
  1493.         else
  1494.         {
  1495.             if(Gtyp[Cpgo] & GEO_OPEN) 
  1496.             {
  1497.                 LastPt[Cobj]  = 0;
  1498.                 cPt = 0;
  1499.                 nPt = 1; 
  1500.             }
  1501.             else 
  1502.             {
  1503.                 LastPt[Cobj]  = Gnpt[Cpgo]-1;
  1504.                 cPt = LastPt[Cobj];
  1505.                 nPt = 0; 
  1506.             }
  1507.         }
  1508.         x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]);
  1509.         y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]);
  1510.         dis = Math.sqrt(x*x + y*y);
  1511.         if(atDis[Cobj] < (dis + DisPt[Cobj])) break;
  1512.         DisPt[Cobj] += dis;
  1513.         LastPt[Cobj]++;
  1514.         if(LastPt[Cobj] >= Gnpt[Cpgo]) 
  1515.         {
  1516.             cPt = 0;
  1517.             nPt = 1;
  1518.             LastPt[Cobj] = 0;
  1519.         }
  1520.     }
  1521.     ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
  1522.     cpox[Cobj] = Gpxl[Cpgo][cPt] + x * ratio;
  1523.     cpoy[Cobj] = Gpyl[Cpgo][cPt] + y * ratio;
  1524.  
  1525.     return;
  1526. }
  1527. else 
  1528. {
  1529.     while(ct <= Gnpt[Cpgo]) 
  1530.     {
  1531.         ct ++;
  1532.         if(LastPt[Cobj]+1 < Gnpt[Cpgo]) 
  1533.         {
  1534.             cPt = Gnpt[Cpgo] - LastPt[Cobj] - 1;
  1535.             nPt = cPt - 1; 
  1536.         }
  1537.         else
  1538.         {
  1539.             if(Gtyp[Cpgo] & GEO_OPEN) 
  1540.             {
  1541.                 LastPt[Cobj]  = Gnpt[Cpgo] - 1;
  1542.                 cPt = Gnpt[Cpgo] - 1;
  1543.                 nPt = cPt - 1; 
  1544.             }
  1545.             else 
  1546.             {
  1547.                 LastPt[Cobj]  = Gnpt[Cpgo];
  1548.                 cPt = 0;
  1549.                 nPt = LastPt[Cobj] - 1; 
  1550.             }
  1551.         }
  1552.         x  = (Gpxl[Cpgo][nPt] - Gpxl[Cpgo][cPt]);
  1553.         y  = (Gpyl[Cpgo][nPt] - Gpyl[Cpgo][cPt]);
  1554.         dis = Math.sqrt(x*x + y*y);
  1555.         if(atDis[Cobj] <= (dis + DisPt[Cobj])) break;
  1556.         DisPt[Cobj] += dis;
  1557.         LastPt[Cobj]++;
  1558.         if(LastPt[Cobj] >= Gnpt[Cpgo]) 
  1559.         {
  1560.             cPt = 0;
  1561.             nPt = 1;
  1562.             LastPt[Cobj] = 0;
  1563.         }
  1564.     }
  1565.     ratio = (atDis[Cobj] - DisPt[Cobj]) / dis;
  1566.     cpox[Cobj] = Gpxl[Cpgo][cPt] + x * ratio;
  1567.     cpoy[Cobj] = Gpyl[Cpgo][cPt] + y * ratio;
  1568.  
  1569.     return;
  1570.     }
  1571. }
  1572.  
  1573. function GetRectLoc() 
  1574. {
  1575.  
  1576. var dis = 0.0;
  1577. while (0==0) 
  1578. {
  1579.     if(rate[Cobj] > 0) 
  1580.     {
  1581.         if(LastPt[Cobj] == 0) 
  1582.         {
  1583.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1584.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1585.             {
  1586.                 cpox[Cobj] = Gpxl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1587.                 cpoy[Cobj] = Gpyl[Cpgo][0];
  1588.                 break; 
  1589.             }
  1590.             LastPt[Cobj] = 1;
  1591.             DisPt[Cobj] += dis; 
  1592.         }
  1593.         if(LastPt[Cobj] == 1) 
  1594.         {
  1595.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1596.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1597.             {
  1598.                 cpox[Cobj] = Gpxl[Cpgo][1];
  1599.                 cpoy[Cobj] = Gpyl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1600.                 break;
  1601.             }
  1602.             DisPt[Cobj] += dis;
  1603.             LastPt[Cobj] = 2;
  1604.         }
  1605.         if(LastPt[Cobj] == 2) 
  1606.         {
  1607.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1608.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1609.             {
  1610.                 cpox[Cobj] = Gpxl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1611.                 cpoy[Cobj] = Gpyl[Cpgo][1];
  1612.                 break; 
  1613.             }
  1614.             DisPt[Cobj] += dis;
  1615.             LastPt[Cobj] = 3; 
  1616.         }
  1617.         if(LastPt[Cobj] == 3) 
  1618.         {
  1619.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1620.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1621.             {
  1622.                 cpox[Cobj] = Gpxl[Cpgo][0];
  1623.                 cpoy[Cobj] = Gpyl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1624.                 break;
  1625.             }
  1626.             DisPt[Cobj] += dis;
  1627.             LastPt[Cobj] = 0;
  1628.         }
  1629.     }
  1630.     else 
  1631.     {
  1632.         if(LastPt[Cobj] == 0) 
  1633.         {
  1634.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1635.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1636.             {
  1637.                 cpox[Cobj] = Gpxl[Cpgo][0];
  1638.                 cpoy[Cobj] = Gpyl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1639.                 break; 
  1640.             }
  1641.             LastPt[Cobj] = 3;
  1642.             DisPt[Cobj] += dis; 
  1643.         }
  1644.         if(LastPt[Cobj] == 3) 
  1645.         {
  1646.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1647.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1648.             {
  1649.                 cpox[Cobj] = Gpxl[Cpgo][0] + (atDis[Cobj]-DisPt[Cobj]);
  1650.                 cpoy[Cobj] = Gpyl[Cpgo][1];
  1651.                 break;
  1652.             }
  1653.             DisPt[Cobj] += dis;
  1654.             LastPt[Cobj] = 2;
  1655.         }
  1656.         if(LastPt[Cobj] == 2) 
  1657.         {
  1658.             dis = (Gpyl[Cpgo][1] - Gpyl[Cpgo][0]);
  1659.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1660.             {
  1661.                 cpox[Cobj] = Gpxl[Cpgo][1];
  1662.                 cpoy[Cobj] = Gpyl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1663.                 break; 
  1664.             }
  1665.             DisPt[Cobj] += dis;
  1666.             LastPt[Cobj] = 1; 
  1667.         }
  1668.         if(LastPt[Cobj] == 1) 
  1669.         {
  1670.             dis = (Gpxl[Cpgo][1] - Gpxl[Cpgo][0]);
  1671.             if((DisPt[Cobj] + dis) > atDis[Cobj]) 
  1672.             {
  1673.                 cpox[Cobj] = Gpxl[Cpgo][1] - (atDis[Cobj]-DisPt[Cobj]);
  1674.                 cpoy[Cobj] = Gpyl[Cpgo][0];
  1675.                 break;
  1676.             }
  1677.             DisPt[Cobj] += dis;
  1678.             LastPt[Cobj] = 0;
  1679.         }
  1680.     }
  1681. }
  1682. return;
  1683. }
  1684.  
  1685. function resetMatrix() {
  1686. cM = 0;
  1687. ob[Cobj].m0 =  1;
  1688. ob[Cobj].m1 =  0;
  1689. ob[Cobj].m2 =  0;
  1690. ob[Cobj].m3 =  1;
  1691. ob[Cobj].m4 =  0;
  1692. ob[Cobj].m5 =  0;
  1693. }
  1694.  
  1695. function appTrans(obj) {
  1696.     resetMatrix();
  1697.     moveMatrix(cpox[obj]+ob[Cobj].corx, cpoy[obj]+ob[Cobj].cory);
  1698.     rotateMatrix(crot[obj]);
  1699.     scaleMatrix(cscx[obj],cscy[obj]);
  1700.     moveMatrix(-ob[Cobj].corx, -ob[Cobj].cory);
  1701. }
  1702.  
  1703. function moveMatrix(x, y) {
  1704.     ob[Cobj].m4 += x * ob[Cobj].m0 + y * ob[Cobj].m2;
  1705.     ob[Cobj].m5 += x * ob[Cobj].m1 + y * ob[Cobj].m3;
  1706. }
  1707.  
  1708. function scaleMatrix(x, y) {
  1709.     ob[Cobj].m0 *= x;
  1710.     ob[Cobj].m1 *= x;
  1711.  
  1712.     ob[Cobj].m2 *= y;
  1713.     ob[Cobj].m3 *= y;
  1714. }
  1715.  
  1716. function rotateMatrix(ang) {
  1717. //var cosAng = Math.cos(0.017453292*ang);
  1718. //var sinAng = Math.sin(0.017453292*ang);
  1719. var cosAng = Math.cos(ang);
  1720. var sinAng = Math.sin(ang);
  1721. var a = ob[Cobj].m0;
  1722. var b = ob[Cobj].m1;
  1723. var c = ob[Cobj].m2;
  1724. var d = ob[Cobj].m3;
  1725. var e = ob[Cobj].m4;
  1726. var f = ob[Cobj].m5;
  1727.  
  1728. ob[Cobj].m0 = a *  cosAng + c * sinAng;
  1729. ob[Cobj].m1 = b *  cosAng + d * sinAng;
  1730. ob[Cobj].m2 = a * -sinAng + c * cosAng;
  1731. ob[Cobj].m3 = b * -sinAng + d * cosAng;
  1732. }
  1733.  
  1734. function tranMatrix(cpob) {
  1735. var a = ob[Cobj].m0;
  1736. var b = ob[Cobj].m1;
  1737. var c = ob[Cobj].m2;
  1738. var d = ob[Cobj].m3;
  1739. var tx= ob[Cobj].m4;
  1740. var ty= ob[Cobj].m5;
  1741.     ob[Cobj].m0 = a * ob[cpob].m0 + b * ob[cpob].m2;
  1742.     ob[Cobj].m1 = a * ob[cpob].m1 + b * ob[cpob].m3;
  1743.  
  1744.     ob[Cobj].m2 = c * ob[cpob].m0 + d * ob[cpob].m2;
  1745.     ob[Cobj].m3 = c * ob[cpob].m1 + d * ob[cpob].m3;
  1746.  
  1747.     ob[Cobj].m4 = tx * ob[cpob].m0 + ty * ob[cpob].m2 + ob[cpob].m4;
  1748.     ob[Cobj].m5 = tx * ob[cpob].m1 + ty * ob[cpob].m3 + ob[cpob].m5;
  1749. }
  1750.  
  1751. function transPt(x1,y1,i) {
  1752.     workX[i] = x1 * ob[Cobj].m0 + y1 * ob[Cobj].m2 + ob[Cobj].m4;
  1753.     workY[i] = x1 * ob[Cobj].m1 + y1 * ob[Cobj].m3 + ob[Cobj].m5;
  1754. }
  1755.  
  1756. function appMtrx() {
  1757.  
  1758. if(Math.abs(cscx[Cobj]) < 0.01) cscx[Cobj] = 0.01;
  1759. if(Math.abs(cscy[Cobj]) < 0.01) cscy[Cobj] = 0.01;
  1760.  
  1761. var x = Gszx[Cgeo] * 0.5;
  1762. var y = Gszy[Cgeo] * 0.5;
  1763. transPt(x,y,0);
  1764. transPt(-x,y,1);
  1765. transPt(-x,-y,2);
  1766. transPt(x,-y,3);
  1767. xl = workX[0];
  1768. yl = workY[0];
  1769. xh = workX[0];
  1770. yh = workY[0];
  1771. for(i=1;i<4;i++) {
  1772. if(workX[i] < xl) xl = workX[i];
  1773. if(workY[i] < yl) yl = workY[i];
  1774. if(workX[i] > xh) xh = workX[i];
  1775. if(workY[i] > yh) yh = workY[i];
  1776. }
  1777. var width = xh - xl;
  1778. var height= yh - yl;
  1779.  
  1780.  
  1781. if(isNav4)
  1782. ob[Cobj].style.resizeTo(width, height);
  1783. else
  1784. {
  1785. ob[Cobj].geom.width  = width;
  1786. ob[Cobj].geom.height = height;
  1787. }
  1788. //window.status = " Cobj=" + Cobj + " x=" + x + " y=" + y + " width=" + width + " height=" + height;
  1789. ob[Cobj].style.left=cpox[Cobj] - width*0.5;
  1790. ob[Cobj].style.top =cpoy[Cobj] - height*0.5;
  1791. }
  1792. //window.status = " Cobj=" + Cobj + " epox[Cobj]=" + epox[Cobj] + " Cgeo=" + Cgeo;
  1793. //window.status = " Deact Cobj=" + Cobj + " WDEvent[Cevt] & (1<<5)=" + WDEvent[Cevt] & (1<<5) + " Active[WDAObj[Cevt]]=" + Active[WDAObj[Cevt]];
  1794. //if(Math.abs(cscx[Cobj]) < 0.01) cscx[Cobj] = 0.01;
  1795. //if(Math.abs(cscy[Cobj]) < 0.01) cscy[Cobj] = 0.01;
  1796. //var x  = Gszx[Cgeo] * 0.5;
  1797. //var y  = Gszy[Cgeo] * 0.5;
  1798. //var x1 = -x * ob[Cobj].m0 + y * ob[Cobj].m2;
  1799. //var y1 = -x * ob[Cobj].m1 + y * ob[Cobj].m3;
  1800. //var width = x1;
  1801. //var height= y1;
  1802. //var x1 = x * ob[Cobj].m0 + y * ob[Cobj].m2;
  1803. //var y1 = x * ob[Cobj].m1 + y * ob[Cobj].m3;
  1804. //if(x1 > width)  width  = x1;
  1805. //if(y1 > height) height = y1;
  1806. //x1 = x * ob[Cobj].m0 + -y * ob[Cobj].m2;
  1807. //y1 = x * ob[Cobj].m1 + -y * ob[Cobj].m3;
  1808. //if(x1 > width)  width  = x1;
  1809. //if(y1 > height) height = y1;
  1810. //x1 = -x * ob[Cobj].m0 + -y * ob[Cobj].m2;
  1811. //y1 = -x * ob[Cobj].m1 + -y * ob[Cobj].m3;
  1812. //if(x1 > width)  width  = x1;
  1813. //if(y1 > height) height = y1;
  1814. //window.status = " Cgeo=" + Cgeo + " Gszx[Cgeo]=" + Gszx[Cgeo] + " Gszy[Cgeo]=" + Gszy[Cgeo] +" width=" + width + " height=" + height;
  1815. //width  = width * 2;
  1816. //height = height* 2;
  1817.